home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / PPCbwb111 / source / bwb_str.c < prev    next >
C/C++ Source or Header  |  1998-06-24  |  7KB  |  306 lines
  1. /***************************************************************
  2.  
  3.         bwb_str.c       String-management routines
  4.                         for Bywater BASIC Interpreter
  5.  
  6.                         Copyright (c) 1992, Ted A. Campbell
  7.  
  8.                         Bywater Software
  9.                         P. O. Box 4023
  10.                         Duke Station
  11.                         Durham, NC  27706
  12.  
  13.                         email: tcamp@acpub.duke.edu
  14.  
  15.         Copyright and Permissions Information:
  16.  
  17.         All U.S. and international copyrights are claimed by the
  18.         author. The author grants permission to use this code
  19.         and software based on it under the following conditions:
  20.         (a) in general, the code and software based upon it may be
  21.         used by individuals and by non-profit organizations; (b) it
  22.         may also be utilized by governmental agencies in any country,
  23.         with the exception of military agencies; (c) the code and/or
  24.         software based upon it may not be sold for a profit without
  25.         an explicit and specific permission from the author, except
  26.         that a minimal fee may be charged for media on which it is
  27.         copied, and for copying and handling; (d) the code must be
  28.         distributed in the form in which it has been released by the
  29.         author; and (e) the code and software based upon it may not
  30.         be used for illegal activities.
  31.  
  32. ***************************************************************/
  33.  
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <string.h>
  37.  
  38. #include "bwbasic.h"
  39. #include "bwb_mes.h"
  40.  
  41. #define FREE_STRBUFFERS    0    /* works with QuickC but not others */
  42.  
  43. #if INTENSIVE_DEBUG || TEST_BSTRING
  44. static char tbuf[ MAXSTRINGSIZE + 1 ];
  45. #endif
  46.  
  47. /***************************************************************
  48.  
  49.         FUNCTION:       str_btob()
  50.  
  51.         DESCRIPTION:    This C function assigns a bwBASIC string
  52.             structure to another bwBASIC string 
  53.             structure.
  54.  
  55. ***************************************************************/
  56.  
  57. int
  58. str_btob( bstring *d, bstring *s )
  59.    {
  60.    char *t;
  61.    register int i;
  62.  
  63. #if TEST_BSTRING
  64.    sprintf( tbuf, "in str_btob(): entry, source b string name is <%s>", s->name );
  65.    bwb_debug( tbuf );
  66.    sprintf( tbuf, "in str_btob(): entry, destination b string name is <%s>", d->name );
  67.    bwb_debug( tbuf );
  68. #endif
  69.  
  70.    /* get memory for new buffer */
  71.  
  72.    if ( ( t = (char *) calloc( s->length + 1, 1 )) == NULL )
  73.       {
  74.       bwb_error( err_getmem );
  75.       return FALSE;
  76.       }
  77.  
  78.    /* write the c string to the b string */
  79.  
  80.    t[ 0 ] = '\0';
  81.    for ( i = 0; i < s->length; ++i )
  82.       {
  83.       t[ i ] = s->buffer[ i ];
  84. #if INTENSIVE_DEBUG
  85.       tbuf[ i ] = s->buffer[ i ];
  86.       tbuf[ i + 1 ] = '\0';
  87. #endif
  88.       }
  89.  
  90.    /* deallocate old memory */
  91.  
  92. #if INTENSIVE_DEBUG
  93.    if ( d->rab == TRUE )
  94.       {
  95.       sprintf( bwb_ebuf, "in str_btob(): reallocating RAB" );
  96.       bwb_debug( bwb_ebuf );
  97.       }
  98. #endif
  99. #if FREE_STRBUFFERS
  100.    if (( d->rab != TRUE ) && ( d->buffer != NULL ))
  101.       {
  102.       free( d->buffer );
  103.       }
  104. #endif
  105.    d->rab = (char) FALSE;
  106.  
  107.    /* reassign buffer */
  108.  
  109.    d->buffer = t;
  110.  
  111.    /* reassign length */
  112.  
  113.    d->length = s->length;
  114.  
  115. #if INTENSIVE_DEBUG
  116.    sprintf( bwb_ebuf, "in str_btob(): exit length <%d> string <%s>",
  117.       d->length, tbuf );
  118.    bwb_debug( bwb_ebuf );
  119. #endif
  120.  
  121.    /* return */
  122.  
  123.    return TRUE;
  124.  
  125.    }
  126.  
  127. /***************************************************************
  128.  
  129.         FUNCTION:       str_ctob()
  130.  
  131.         DESCRIPTION:    This C function assigns a null-terminated
  132.             C string to a bwBASIC string structure.
  133.  
  134. ***************************************************************/
  135.  
  136. int
  137. str_ctob( bstring *s, char *buffer )
  138.    {
  139.    char *t;
  140.    register int i;
  141.  
  142. #if INTENSIVE_DEBUG
  143.    sprintf( tbuf, "in str_ctob(): entry, c string is <%s>", buffer );
  144.    bwb_debug( tbuf );
  145. #endif
  146. #if TEST_BSTRING
  147.    sprintf( tbuf, "in str_ctob(): entry, b string name is <%s>", s->name );
  148.    bwb_debug( tbuf );
  149. #endif
  150.  
  151.    /* get memory for new buffer */
  152.  
  153.    if ( ( t = (char *) calloc( strlen( buffer ) + 1, 1 )) == NULL )
  154.       {
  155.       bwb_error( err_getmem );
  156.       return FALSE;
  157.       }
  158.  
  159.    /* write the c string to the b string */
  160.  
  161.    t[ 0 ] = '\0';
  162.    for ( i = 0; i < strlen( buffer ); ++i )
  163.       {
  164.       t[ i ] = buffer[ i ];
  165. #if INTENSIVE_DEBUG
  166.       tbuf[ i ] = buffer[ i ];
  167.       tbuf[ i + 1 ] = '\0';
  168. #endif
  169.       }
  170.  
  171.    /* deallocate old memory */
  172.  
  173. #if INTENSIVE_DEBUG
  174.    if ( s->rab == TRUE )
  175.       {
  176.       sprintf( bwb_ebuf, "in str_ctob(): reallocating RAB" );
  177.       bwb_debug( bwb_ebuf );
  178.       }
  179. #endif
  180. #if FREE_STRBUFFERS
  181.    if (( s->rab != TRUE ) && ( s->buffer != NULL ))
  182.       {
  183.       free( s->buffer );
  184.       }
  185. #endif
  186.    s->rab = (char) FALSE;
  187.  
  188.    /* reassign buffer */
  189.  
  190.    s->buffer = t;
  191.  
  192.    /* reassign length */
  193.  
  194.    s->length = (unsigned char) strlen( buffer );
  195.  
  196. #if INTENSIVE_DEBUG
  197.    sprintf( bwb_ebuf, "in str_ctob(): exit length <%d> string <%s>",
  198.       s->length, tbuf );
  199.    bwb_debug( bwb_ebuf );
  200. #endif
  201.  
  202.    /* return */
  203.  
  204.    return TRUE;
  205.  
  206.    }
  207.  
  208. /***************************************************************
  209.  
  210.         FUNCTION:       str_btoc()
  211.  
  212.         DESCRIPTION:    This C function assigns a null-terminated
  213.             C string to a bwBASIC string structure.
  214.  
  215. ***************************************************************/
  216.  
  217. int
  218. str_btoc( char *buffer, bstring *s )
  219.    {
  220.    register int i;
  221.  
  222. #if INTENSIVE_DEBUG
  223.    sprintf( tbuf, "in str_btoc(): entry, b string length is <%d>", 
  224.       s->length );
  225.    bwb_debug( tbuf );
  226. #endif
  227. #if TEST_BSTRING
  228.    sprintf( tbuf, "in str_btoc(): entry, b string name is <%s>", s->name );
  229.    bwb_debug( tbuf );
  230. #endif
  231.  
  232.    /* write the b string to the c string */
  233.  
  234.    buffer[ 0 ] = '\0';
  235.    for ( i = 0; i < s->length; ++i )
  236.       {
  237.       buffer[ i ] = s->buffer[ i ];
  238.       buffer[ i + 1 ] = '\0';
  239.       if ( i >= MAXSTRINGSIZE )
  240.          {
  241.          i = s->length + 1;
  242.          }
  243.       }
  244.  
  245. #if INTENSIVE_DEBUG
  246.    sprintf( tbuf, "in str_btoc(): exit, c string is <%s>", buffer );
  247.    bwb_debug( tbuf );
  248. #endif
  249.  
  250.    /* return */
  251.  
  252.    return TRUE;
  253.  
  254.    }
  255.  
  256. /***************************************************************
  257.  
  258.         FUNCTION:       str_cat()
  259.  
  260.         DESCRIPTION:    This C function 
  261.  
  262. ***************************************************************/
  263.  
  264. char *
  265. str_cat( bstring *a, bstring *b )
  266.    {
  267.    char abuf[ MAXSTRINGSIZE + 1 ];
  268.    char bbuf[ MAXSTRINGSIZE + 1 ];
  269.    char *r;
  270.  
  271.    str_btoc( abuf, a );
  272.    str_btoc( bbuf, b );
  273.  
  274. #if INTENSIVE_DEBUG
  275.    sprintf( bwb_ebuf, "in str_cat(): a <%s> b <%s>", abuf, bbuf );
  276.    bwb_debug( bwb_ebuf );
  277. #endif
  278.  
  279.    r = strcat( abuf, bbuf );
  280.    str_ctob( a, abuf );
  281.  
  282.    return r;
  283.    }
  284.  
  285. /***************************************************************
  286.  
  287.         FUNCTION:       str_cmp()
  288.  
  289.         DESCRIPTION:    This C function 
  290.  
  291. ***************************************************************/
  292.  
  293. int
  294. str_cmp( bstring *a, bstring *b )
  295.    {
  296.    char abuf[ MAXSTRINGSIZE + 1 ];
  297.    char bbuf[ MAXSTRINGSIZE + 1 ];
  298.  
  299.    str_btoc( abuf, a );
  300.    str_btoc( bbuf, b );
  301.  
  302.    return strcmp( abuf, bbuf );
  303.    }
  304.  
  305.  
  306.